package com.zackeus.mvvm.utils;

import androidx.lifecycle.Lifecycle;

import com.trello.rxlifecycle4.LifecycleProvider;
import com.trello.rxlifecycle4.LifecycleTransformer;
import com.zackeus.mvvm.api.ExceptionHandle;

import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
import io.reactivex.rxjava3.annotations.NonNull;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.core.ObservableSource;
import io.reactivex.rxjava3.core.ObservableTransformer;
import io.reactivex.rxjava3.core.Scheduler;
import io.reactivex.rxjava3.functions.Function;
import io.reactivex.rxjava3.schedulers.Schedulers;

/**
 * Rx的工具类
 */
public class RxUtils {

    /**
     * 生命周期绑定
     * @param lifecycle
     * @param <T>
     * @return
     */
    public static <T> LifecycleTransformer<T> bindToLifecycle(@NonNull LifecycleProvider<Lifecycle.Event> lifecycle) {
        return lifecycle.bindToLifecycle();
    }

    /**
     * 线程调度器
     * 指定被观察者使用 Schedulers.io() 线程操作, 指定观察者使用 mainThread 执行
     */
    public static <T> ObservableTransformer<T, T> schedulersTransformer() {
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(Observable<T> upstream) {
                return upstream.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
            }
        };
    }

    /**
     * 线程调度器
     * @param scheduler 线程种类
     *                  Schedulers.immediate() 直接在当前线程运行，相当于不指定线程
     *                  Schedulers.newThread() 总是启动新线程，在新的线程中执行操作
     *                  Schedulers.io() I/O操作所使用的Scheduler 内部实现是用一个无数量上限的线程池
     *                  Schedulers.computation() 计算所使用的Scheduler 这个计算是指CPU密集型计算，即不会被I/O等操作限制性的操作
     *                  Schedulers.trampoline() 当其它排队的任务完成后，在当前线程排队开始执行
     *                  AndroidSchedulers.mainThread() 在RxAndroid中，他指定操作将在Android主线程中执行
     * @param <T>
     * @return
     */
    public static <T> ObservableTransformer<T, T> schedulersTransformer(Scheduler scheduler) {
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(Observable<T> upstream) {
                return upstream.subscribeOn(scheduler).observeOn(AndroidSchedulers.mainThread());
            }
        };
    }

    /**
     * 异常调度器
     * @param <T>
     * @return
     */
    public static <T> ObservableTransformer<T, T> exceptionTransformer() {
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(Observable<T> upstream) {
                return upstream.onErrorResumeNext(new ErrorResponseFunc<>());
            }
        };
    }

    /**
     * 异常调度器
     * @param observable
     * @param <T>
     * @return
     */
    public static <T> ObservableTransformer<T, T> exceptionTransformer(Observable<T> observable) {
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(Observable<T> upstream) {
                return upstream.onErrorResumeWith(observable);
            }
        };
    }

    /**
     * 异常监听者
     * @param <T>
     */
    private static class ErrorResponseFunc<T> implements Function<Throwable, Observable<T>> {
        @Override
        public Observable<T> apply(Throwable t) {
            return Observable.error(ExceptionHandle.handleException(t));
        }
    }

}
